

//1.获取原始chatData
//2.对chatData的某个  键  进行分词处理并存储到tempData中
//3.将分词结果展平（一维对象数组）赋值给temp
//4.将temp中的segment键值存储到strings（字符串数组）中
//5.对strings进行过滤，返回给chatDataSplit
//6.对chatDataSplit中每个值出现的次数进行统计，并进行降序排列，返回统计结果data

import {ref} from "vue";

export function anaDataSplitWord(data, dataKey){
    //2.对data的某个  键  进行分词处理并存储到tempData中
    //注意如果 ref变量是数组的话，必须定义[]， 否则会push出错
    let tempData = ref([])
    data.forEach((chat)=>{
        tempData.value.push(
            //注意：这里是把分词结果的对象都存到tempData中了，而不是把分词结果。所以后面还需要处理的
            Array.from(new Intl.Segmenter("cn",{granularity:'word'}).segment(chat[dataKey]))
        )
    })
    //3.将分词结果展平（一维对象数组）赋值给temp
    //4.将temp中的segment键值存储到strings（字符串数组）中
    let strings = ref([])
    let temp:[] = tempData.value.flat()
    temp.forEach((e)=>{
        strings.value.push(e.segment);
    })
    //5.对strings进行过滤，返回给filterStrings
    let filterStrings = ref()
    filterStrings.value = strings.value.filter(function(item) {
        return item !== "？" && item !== "。" && item !== "中的"
            && item !== "在" && item !== "中有" && item !== "有"
            && item !== "是" && item !== "对" && item !== "，"
            && item !== "它" && item !== "他" && item !== "她"
            && item !== "的" && item !== "地" && item !== "得"
            && item !== "和" && item !== "、" && item !== "可以"
            && item !== "减" && item !== "中" && item !== "了"
            && item !== "可" && item !== "于" && item !== "一"
            && item !== "助" && item !== "力" && item !== "其"
            && item !== "一个" && item !== "动" && item !== "指"
            && item !== "吗" && item !== "." && item !== " "
            && item !== "排" && item !== "等" && item !== "低"
            && item !== "包括" && item !== "用" && item !== "你好"
    });
    //6.对filterStrings中每个值出现的次数进行统计，并进行降序排列，并直接返回
    let resultData = countKeyValueSort(filterStrings.value)

    //进行截断，避免返回过多
    if(resultData.length>25){
        return resultData.slice(0, 25)
    }
    return resultData
}


// dataKey应该是一个 time相关的。
export function anaDataTime(data,dataKey,maxNum){
    let tempData = ref([])
    data.forEach((e)=>{
        tempData.value.push(e[dataKey].substring(14,16))
    })
    let resultData = countKeyValueSort(tempData.value)
    //返回前  maxNum 个
    if(resultData.length>maxNum){
        return resultData.slice(0, maxNum)
    }
    return resultData
}

export function anaDataDate(data,dataKey){
    let tempData = ref([])
    data.forEach((e)=>{
        tempData.value.push(e[dataKey].substring(5,10))
    })
    let resultData = countKeyValue(tempData.value)
    //返回 最新的 7个（一周。因为存数据都是按照时间存的，所以正常来说，数据就是按顺序处理的。
    if(resultData.length>7){
        return resultData.slice(-7)
    }
    return resultData
}


//统计 字符串数组中 每个字符串出现的次数，并返回 降序的 {name、value}对象数组。 封装成方法
function countKeyValueSort(strings){
    let resultData =ref()
    const questionMap = new Map<string, number>();
    strings.forEach((e) => {
        if (questionMap.has(e)) {
            questionMap.set(e, questionMap.get(e)! + 1);
        } else {
            questionMap.set(e, 1);
        }
    });
    resultData.value = Array.from(questionMap).map(([name, value]) => ({ name, value }));
    return  resultData.value.sort((b, a) => a.value - b.value)
}

function countKeyValue(strings){
    let resultData =ref()
    const questionMap = new Map<string, number>();
    strings.forEach((e) => {
        if (questionMap.has(e)) {
            questionMap.set(e, questionMap.get(e)! + 1);
        } else {
            questionMap.set(e, 1);
        }
    });
    resultData.value = Array.from(questionMap).map(([name, value]) => ({ name, value }));
    return  resultData.value
}